//+================================================================================================+
//|                                                                                  2Sides_v5.0c5 |
//|                                                                               by Edition Qimer |
//|                                                                                     31.05.2013 |
//|                                                                                                |
//|                                                                   2Sides_Stoch_v5.0c5_1090.mq4 |
//|                                                                by Modification Edition Joker62 |
//|                                                                                     18.10.2017 |
//|                                                                                                |
//|                                  https://www.forexdengi.com/threads/58392-2sides-stoch/page147 |
//+================================================================================================+
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#property copyright "2Sides_v5.0c5 & Qimer"
#property strict
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Для работы советника необходимо выполнить ряд условий, в противном случае нормальная работа советника не гарантируется.
//
// 1) Разрешенный максимальный совокупный объем открытых ордеров в каждую из сторон должен быть не меньше 100лот (информацию об этом можно узнать на
//    сайте вашего ДЦ «типы счетов»)
// 2) Плечо (leverage), чем оно выше, тем меньший депозит будет необходим для торговли, и тем выше будет прибыль. Меньшее плечо убережет депо от вашей
//    жадности и неоправданного риска.
// 3) Необходимый депозит. Торговать можно с любым депозитом. Однако, при UseMM = true советник, в случае нехватки средств на счете, выведет
//    соответствующее сообщение и укажет, сколько необходимо иметь средств на счете при данных настройках советника.
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Подправлены для нормальной работы под билда терминала 1090.
// Объединено ряд модулей и функции рижима LOT  в один блок
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
enum NoYes
 {
  ny0 = 0, // Нет (False)
  ny1 = 1  // Да  (True)
 };
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
extern string separate_00____ = "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; //.
extern string tx1             = "Общие настройки советника";                      //.
extern NoYes  Info            = true;                 // Отображать инфо панель?
                                                      // Переключатель, при значении true, отображается информация о балансе,
                                                      // ордерах, коэффициенте увеличения лота и т.д.
extern color  MainInfoBack    = LightGray;
extern color  MainInfo        = Black;
extern color  BuyInfoBack     = LightGray;
extern color  BuyInfo         = Black;
extern color  SellInfoBack    = LightGray;
extern color  SellInfo        = Black;
extern string separate_01____ = "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; //.
input  NoYes  UseVTP          = true;                 // Будем использовать виртуальный трал?
                                                      // Переключатель, при значении false советник использует режим, в котором советник модифицирует
                                                      // ордера с выставлением фактического ТП серии, и серии закрываются брокером. При значении true
                                                      // советник использует режим VTP с выставлением виртуального ТП и закрытием ордеров серии по
                                                      // сигналу советника, также в этом режиме используется трейлинг прибыли.
                                                      //---------------------------------------------------------------------------------------------
                                                      // В режиме VTP советник использует горизонтальные линии ТП (Virtual TakeProfit) для закрытия ордеров.
                                                      // При очередном (ручном/автоматическом) открытии ордера серии советник рассчитывает новый уровень
                                                      // цены для перемещения линии ТП.
                                                      // При выходе цены за линию ТП (для «buy серии» снизу вверх, для «sell серии»  сверху вниз) на расстояние,
                                                      // задаваемое в опциях как Tral_Start, линия ТП меняет свой цвет на, заданный в опциях советника, цвет Tral_Color.
                                                      // Это свидетельствует о начале трала прибыли по серии. При продолжении движения цены в нужном направлении,
                                                      // линия ТП будет следовать за ценой на расстоянии не более Tral_Size. При развороте цены, серия закроется
                                                      // на уровне подтянутой линии ТП.
                                                      // Важно отметить, что при удалении линии ТП, трал отменится и линия займет свое первоначальное положение.
                                                      // Также необходимо отметить, что теперь линии ТП можно двигать, тем самым выбирая для себя необходимый
                                                      // уровень закрытия серии, ожидаемый профит в единицах валюты отображается чуть ниже линии ТП. Т.е. можно
                                                      // подобрать как необходимый уровень закрытия по определенной цене, так и необходимый профит.
                                                      // Принудительное закрытие сери осуществляется точно так же.. Заводим линию ТП за цену, чтобы сработал трал.
                                                      // Затем заводим линию за цену в обратном направлении, чтобы сработало закрытие серии.
                                                      // В режиме UseVTP = false перемещение линий ТП влечет за собой изменение терминальных ТП. Режим защищен от
                                                      // ошибки 130 (близкие стопы). Поэтому можно смело двигать линию. Важно только одно, что модификация ордеров
                                                      // происходит сразу, поэтому не стоит долго перемещать эту линию, т.к. будет много модификаций ордеров и
                                                      // обращений на сервер, что не приветствуется большинством ДЦ.
                                                      //---------------------------------------------------------------------------------------------
extern NoYes  CloseBy        = false;                 // Будем использовать встречный ордер?
                                                      // Переключатель, при значении true советник закрывает серии, используя встречное закрытие ордеров,
                                                      // при значении false советник закрывает серии последовательно, начиная с большего ордера.
extern NoYes  ManualTrade    = false;                 // Будем открывать первый ордер в ручную?
                                                      // Переключатель, при значении true переходит в режим ручной торговли, т.е. первый ордер открывает
                                                      // сам трейдер, а советник, в случае неверного движения цены, сопровождает открытый ордер.
extern NoYes  DynamicTP      = false;                 // Будем изменять достижения профита?
                                                      // Переключатель, в положении true переходит в режим, при котором общий ТейкПрофит серий будет
                                                      // зависить от количество ордеров в сериях Sell и Buy (значения независимы)
extern NoYes  UseNewBar      = true;                  // Использовать режим открытия колен на новом баре?
                                                      // Переключатель, в положении true переходит в режим, при котором каждое новое колено серии будет
                                                      // открываться на новом баре (работа зависит на каком ТФ стоит советник, т.е. на ТФ H1 новые колени
                                                      // серии будут открываться не раньше чем через час)
extern int    UNB_TF         = 0;                     // Использовать UseNewBar по заданному тайм-фрейму?
                                                      // Использовать UseNewBar по заданному тайм-фрейму. По умолчанию - текущий тайм-фрейм.
extern NoYes  ZTP            = false;                 // Будем переводит серии в безубыток?
                                                      // Переключатель, в положении true переходит в режим, при котором советник после достижения
                                                      // определенного количества ордеров (ZTP_order) в серии, переводит ТП в безубыток
extern int    ZTP_order      = 6;                     // Количество ордеров до начала выполнения в безубыток:
extern int    DaysBuffer     = 2;                     // Будем сохранять все сделок на чарте-окна?
                                                      // Количество дней, в течении которых советник хранит на графике объекты (такие как открытие/закрытие ордеров)
extern int    magicbuy       = 121;                   // Меджик для BUY:
                                                      // Идентификатор меджика для открытия и закрытия (серии) ордера Buy:
extern int    magicsell      = 122;                   // Меджик для SELL:
                                                      // Идентификатор меджика для открытия и закрытия (серии) ордера Sell:
extern int    magiclock      = 135797531;             // Меджик встречного ордера CloseBy:
                                                      // Идентификатор для встречного ордера, при включенном режиме CloseBy
extern string magic_list     = "454 455 0";           // Список меджиков без пробелов:
                                                      // Идентификаторы ордеров, которые советник будет считать своими. Заполняется с пробелом между
                                                      // цифрами. Никаких лишних символов!
extern color  BuyColor       = Blue;                  // Цвет линий для серий Buy:
extern color  SellColor      = Red;                   // Цвет линий для серий Sell:
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
extern string separate_02___ = "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; //.
extern string tx2            = "Настройки системы LOT (Last Orders Take Profit)";//.
extern NoYes  LOT            = false;                 // Будем использовать режим LOT?
                                                      // Переключатель, в положении true переходит в режим LOT. В этом режиме сов находит точку безубытка
                                                      // последних 2-х ордеров серии и с помощью трала собирает прибыль по этим двум ордерам и выставляет
                                                      // новое колено в серии, но уже чуть дальше, чем обычно. Таким образом, при малых откатах цены в
                                                      // положительную сторону для серии собирается прибыль, которая накапливается в переменной, чтобы в
                                                      // дальнейшем закрыть серию при достижении процента прибыли ProfitPercent (Советник не просто сравнивает
                                                      // накопленную прибыль с установленным в опциях процентом, но еще и сверяется со Средствами/Equity)
extern int    nOrder         = 5;                     // С какого номера начинать работу LOT:
                                                      // Порядковый номер ордера в серии, с которого включается LOT.
extern int    LO_TP          = 5;                     // ТейкПрофит для LOT:
                                                      // ТейкПрофит для LOT, количество пунктов от без убытка. Важно отметить, что на уровень этого ТП
                                                      // влияет и TPstep. Формула такая: TP = LO_TP + Tpstep * trades, (где trades - количество текущих
                                                      // ордеров серии)
extern int    LO_Tral_Start  = 3;                     // Через сколько пунктов начинать трал LOT:
                                                      // Количество пунктов, на которое цена должна зайти за линию LO_TP, чтобы начался трал
extern int    LO_Tral_Size   = 5;                     // Количество пунктов, величина трала для LOT:
extern int    ProfitPercent  = 15;                    // Процент достижения по ТейкПрофиту от размера баланса:
                                                      //---------------------------------------------------------------------------------------------
                                                      // Данная система имеет как плюсы, так и минусы. К плюсам относится существенная прибыль при резких
                                                      // бросках цены, сдвиг ордеров, что немного уменьшает просадку. К минусам – затяжные просадки при
                                                      // вялом тренде. Не рекомендую использовать LOT на больших депозитах с большим уровнем риска
                                                      // (UseMoney > 30) и/или с низким числом ордеров в серии (MaxTrades < 8).
                                                      //---------------------------------------------------------------------------------------------
extern color  LOTColor       = Purple;                // Цвет линии ТП, при трале последних 2-х ордеров:
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
extern string separate_03___ = "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; //.
extern string tx3            = "Время работы советника";                         //.
extern int    StartHour      = 21;                    // Время начала интервала работы советника (время терминала):
extern int    EndHour        = 4;                     // Время конца интервала работы советника (время терминала):
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
extern string separate_04___ = "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; //.
extern string tx4            = "Настройки MoneyManagement";                      //.
extern NoYes  UseMM          = true;                  // Будем использовать Money Management?
                                                      // Переключатель, при значении true объем первого ордера серии рассчитывается советником, а при
                                                      // значении false объем первого ордера задает сам пользователь через переменную min_lot (выключать
                                                      // UseMM советую лишь зная, что min_lot у вас меньше, чем рассчитанный в блоке ММ, иначе нормальная
                                                      // работа советника не гарантируется!)
extern NoYes  UseEquity      = true;                  // Использовать в рачете размера лота по эквити?
                                                      // Переключатель, при значении true в расчете объема 1-го ордера серии участвует не баланс, а средства.
                                                      // Позволяет советнику корректно работать на счете, в котором есть локированая серия ордеров.
extern double min_lot        = 0.1;                   // Минимальный начальный размер лота для торговли:
                                                      // Минимальный начальный размер лота для торговли. Минимальный допустимый размер лота уточняйтесь в своем ДЦ!
extern int    MaxTrades      = 6;                     // Максимальое кол-во ордеров в сериях:
                                                      // Здесь задается максимальное количество ордеров в сериях. Например, при значении MaxTrades = 4
                                                      // советник откроет, если понадобится, лишь 3 дополнительных ордера (колен мартингейла).
extern int    UseMoney       = 50;                    // Уровень риска от размера депо в %:
                                                      // Процент использования баланса для расчета (можно понимать как «риск»)
                                                      //---------------------------------------------------------------------------------------------
                                                      // Советник рассчитывает максимальный объем для первого ордера серии таким образом, чтобы смогло
                                                      // открыться то количество ордеров, которое указано в переменной MaxTrades. Т.е. если указано
                                                      // MaxTrades = 7 и Step = 30, то фактически советник рассчитывает на максимальное безоткатное движение в
                                                      // 7 * 30 + 30 = 240 пунктов (2400 для пятизнаков). Если UseMoney = 100, то при 241 - 250 пунктах безотката
                                                      // произойдет слив депо. Чтобы застраховать депо, можно понизить значение UseMoney.
                                                      //---------------------------------------------------------------------------------------------
                                                      // Важно отметить, что может сложиться такая ситуация, когда рассчитанный максимально возможный
                                                      // объем для первой сделки будет меньше минимально возможного объема на данном счете, тогда советник
                                                      // выдаст сообщение о нехватке средств со значением необходимого депозита для торговли, с учетом текущих
                                                      // настроек советника. Поэтому адекватно выбирайте значения MaxTrades, UseMoney, mult и проверяйте сначала
                                                      // на тестере.
                                                      //---------------------------------------------------------------------------------------------
extern int    SL_Level       = 40;                    // Уровень просадки в процентах:
extern NoYes  DrawdownStop   = false;                 // Будем принудительно закрывать все ордера?
                                                      // Переключатель, в положение DrowdownStop = true, советник принудительно закроет все открытые серии,
                                                      // мэджик ордеров которых соответствует установленному в настройках magic.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
extern string separate_05___ = "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; //.
extern string tx5            = "Основные настройки";                             //.
extern NoYes  CurrencyProfit = false;                 // Будем использовать расчет ТП в %?
                                                      // Переключатель, в положении true переходит в режим, при котором ТейкПрофит будет рассчитываться
                                                      // не в пунктах, а в процентах от баланса, который был на момент открытия первого ордера серии
extern double Profit         = 1.0;                   // Процент в прибыдях:
                                                      // Процент прибыли при режиме CurrencyProfit = true
extern int    TP             = 8;                     // ТП для 1-го ордера:
                                                      // ТейкПрофит для первого ордера серии, в пунктах от безубытка
extern int    TP1            = 8;                     // ТП в сериях:
                                                      // ТейкПрофит для каждой серии, в пунктах от безубытка (цены, при которой серия закроется в 0)
extern int    TPstep         = 2;                     // Шаг для динамического изменения достижения профита:
                                                      // Количество пунктов, на которое будет увеличиваться ТП серии при открытии нового колена. Переменная
                                                      // введена для того, чтобы профит соответствовал риску, больше риск (просадка) –> больше профит
extern int    Tral_Start     = 5;                     // Старт трейлинга VTP
                                                      // Количество пунктов, на которое цена должна зайти за линию TP, чтобы начал работать трейлинг
                                                      // (только для режима VTP)
extern int    Tral_Size      = 5;                     // Размер трейлинг стопа VTP:
                                                      // Размер трейлинг стопа (только для режима VTP)
extern color  TralColor      = Yellow;                // Цвет линии ТП при финальном трейлинге профита:
extern int    step           = 30;                    // ПипСтеп, шаг в пунктах для открытия колен мартингейла:
extern double Step_coef      = 1;                     // Множитель шага в серии:
                                                      // Множитель пипстепа, для очередного колена серии рассчитывается новый пипстеп.
                                                      // Step = Step_coef * i, (где i – i-й ордер серии)
extern double mult           = 2;                     // Множитель для лота в серии:
                                                      // Множитель лота для новых колен (то же, что и LotExponent), выражает во сколько раз очередной
                                                      // ордер серии будет превосходить предыдущий по объему
extern int    slippage       = 3;                     // Проскальзывание цены при реквотах:
                                                      // Максимальное отклонение цены для открытия ордера при реквотах (проскальживание)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
enum TFSt
 {
  tfs0 = 0,     // Текущий
  tfs1 = 1,     // 1 минута
  tfs2 = 5,     // 5 минут
  tfs3 = 15,    // 15 минут
  tfs4 = 30,    // 30 минут
  tfs5 = 60,    // 1 час
  tfs6 = 240,   // 4 часа
  tfs7 = 1440,  // 1 день
  tfs8 = 10080, // 1 неделя
  fts9 = 43200  // 1 месяц
 };
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
extern string separate_06___ =  "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; //.
extern string tx6            = "Настройки индикатора Stochastic";                 //.
extern TFSt   StochTime      = 5;                     // Тайм-фрейм для индикатора Stochastic:
                                                      // Таймфрейм на котором работает индикатор Stochastic. Значение выражено в минутах, соответственно
                                                      // M1 – 1, M5 – 5, M30 – 30, H1 – 60, H4 – 240, D1 – 1440 и т.д.
extern int    per_K          = 10;                    // Период линии K:
extern int    per_D          = 3;                     // Период линии D:
extern int    slow           = 3;                     // Скорость замедления:
extern ENUM_MA_METHOD S_Mode = 0;                     // Метод усредения:
extern int    S_Price        = 0;                     // Тип цены (Low/High = 0 / Close/Close = 1):
extern int    zoneBUY        = 15;                    // Зона перекупленности BUY:
extern int    zoneSELL       = 85;                    // Зона перепроданности SELL:
extern string separate_07___ =  "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; //.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       double minLot,               maxLot,
              lotsbuy,              lotssell,
              LOTStep,              
              smbuy,                smsell,
              vmtpb,                vmtps,
              vLO_mtpb,             vLO_mtps,
              BalanceBuy,           BalanceSell,
              ProfitBuy,            ProfitSell,
              pr1,                  pr2,
              ProfitBuyN,           ProfitSellN,
              LastOrdersBuyProfit,  LastOrdersSellProfit,
              LastOrdersBuyLots,    LastOrdersSellLots;
       
       int    LO_tral,   tral,
              i,         j,
              CU,        totb,
              tots,      r,
              cnt,       dig,
              hb = 0,    hs = 0,
              TicketB[], TicketS[],
              magic[10], cmagic,
              cntr = 0;
       
       color  col,       vctpb,
              vctps,     vcLO_mtpb,
              vcLO_mtps;
       
       string txt1,      txt2,
              txt3,      txt4,
              txtVTP,    txtLOT,
              tm;
       
       bool   TradeOff,  NotFast;
       
       datetime NewBar_B, NewBar_S;
//===================================================================================================================================================
int OnInit()
 {
  TradeOff = false;
  
  LOTStep = MarketInfo(Symbol(), MODE_LOTSTEP);
  minLot  = MarketInfo(Symbol(), MODE_MINLOT);
  maxLot  = MarketInfo(Symbol(), MODE_MAXLOT);
  
  dig = 2;                                                                // количество знаков после запятой
  
  if (!IsTesting() || IsVisualMode())
   NotFast = true;
  
  if (Digits == 4 ||                                                      // коэффициент для разных типов счетов 4/2 и 5/3
      Digits == 2)
   CU = 1;
  else
   CU = 10;
  
  LO_TP         *= CU;                                                    // увеличиваем все необходимые параметры на этот коэффиент
  LO_Tral_Start *= CU;
  slippage      *= CU;
  TP1           *= CU;
  TP            *= CU;
  TPstep        *= CU;
  Tral_Start    *= CU;
  step          *= CU;
  
  tral    = Tral_Size    * CU;
  LO_tral = LO_Tral_Size * CU;
  
  double lotx = MM(mult, UseMoney, MaxTrades, step);                      // производится проверка, удовлетворяет ли баланс
                                                                          // настройкам, заданным в советнике.
  if (UseMM && lotx < minLot)
   TradeStop();
  
  if (!UseMM && min_lot < minLot)
   {
    tm       = "min_lot меньше возможного на счете";                      // Защита от неверно введенного парамтера min_lot
    TradeOff = true;
   }
  
  cmagic = 0;
  
  string st;
  
  int k = StringLen(magic_list);
  
  for (int a = 0; a < k; a++)
   {
    if (StringSubstr(magic_list, a, 1) != " ")
     {
      st = st + StringSubstr(magic_list, a, 1);
      
      if (a < k - 1)
       continue;
     }
    
    if (st != "")
     {
      magic[cmagic] = StrToInteger(st);
      cmagic++;
      st =" ";
     }
   }
  
  double gtpb = GlobalVariableGet("2ss_TPBuy"),
         gtps = GlobalVariableGet("2ss_TPSell");
  
  if (gtpb > 0)
   DrawLine("SellTP", gtpb, SellColor, 2);
  
  if (gtps > 0)
   DrawLine("BuyTP", gtps, BuyColor, 2);
  
  //--------------------------------
  return(INIT_SUCCEEDED);
 }
//===================================================================================================================================================
void OnDeinit(const int reason)
 {
  Comment("");
  
  double gtpb = ObjectGet("BuyTP",  OBJPROP_PRICE1),
         gtps = ObjectGet("SellTP", OBJPROP_PRICE1);
  
  if (gtpb > 0)
   GlobalVariableSet("2ss_TPBuy", gtpb);
  
  if (gtps > 0)
   GlobalVariableSet("2ss_TPSell", gtps);
  
  ObjectDelete("SellTP");
  ObjectDelete("BuyTP");
  
  ObjectDelete("SellZeroLevel");
  ObjectDelete("BuyZeroLevel");
  
  ObjectDelete("SellLOT");
  ObjectDelete("BuyLOT");
  
  ObjectDelete("Lable1");
  ObjectDelete("Lable2");
  ObjectDelete("Lable3");
  
  ObjectDelete("y_MainInfoBack1");
  ObjectDelete("y_MainInfoBack2");
  ObjectDelete("y_MainInfoBack3");
  
  ObjectDelete("z_MainInfo_1");
  ObjectDelete("z_MainInfo_2");
  ObjectDelete("z_MainInfo_3");
  ObjectDelete("z_MainInfo_4");
  ObjectDelete("z_MainInfo_5");
  ObjectDelete("z_MainInfo_6");
  ObjectDelete("z_MainInfo_7");
  
  ObjectDelete("z_BuyInfo_1");
  ObjectDelete("z_BuyInfo_2");
  ObjectDelete("z_BuyInfo_3");
  ObjectDelete("z_BuyInfo_4");
  ObjectDelete("z_BuyInfo_5");
  ObjectDelete("z_BuyInfo_6");
  ObjectDelete("z_BuyInfo_7");
  
  ObjectDelete("z_SellInfo_1");
  ObjectDelete("z_SellInfo_2");
  ObjectDelete("z_SellInfo_3");
  ObjectDelete("z_SellInfo_4");
  ObjectDelete("z_SellInfo_5");
  ObjectDelete("z_SellInfo_6");
  ObjectDelete("z_SellInfo_7");
  
  ObjectDelete("z_ErrorB");
  ObjectDelete("z_ErrorM");
  
  ObjectDelete("BuyTP_Back");
  ObjectDelete("BuyTP_Text");
  
  ObjectDelete("SellTP_Back");
  ObjectDelete("SellTP_Text");
  
  //----------------------------
  return;
 }
//===================================================================================================================================================
void OnTick()
 {
 double profitbuy    = 0, profitsell    = 0,
        openpricebuy = 0, openpricesell = 0,
        lastlotbuy   = 0, lastlotsell   = 0,
        TPB          = 0, TPS           = 0;
  double TV     = MarketInfo(Symbol(), MODE_TICKVALUE);
  double spread = MathFloor(MarketInfo(Symbol(), MODE_SPREAD));
  
  ProfitBuyN  = 0; ProfitSellN = 0;
  
  //-------------------------------- Запрет торговли ------------------------------------
  if (TradeOff)
   {
    Text("z_ErrorB", "gggggggggggggggggggggggggg", 24, "Webdings", 100, 200, Red);
    Text("z_ErrorM", "Торговля остановлена! " + tm, 15, "Arial Black", 110, 201, Yellow);
    
    return; //(0);
   }
  
  //================================================== Сбор данных о торговле =========================================
  totb = 0;
  tots = 0;
  
  ArrayResize(TicketB, OrdersTotal());
  ArrayResize(TicketS, OrdersTotal());
  
  //-------------------------- Заполнение массивов тикетов ------------------------------
  for (r = 0; r < OrdersTotal(); r++)
   {
    if (OrderSelect(r, SELECT_BY_POS, MODE_TRADES))
     {
      if (OrderSymbol() == Symbol())
       {
        if (OrderType()        == OP_BUY   &&
           (OrderMagicNumber() == magicbuy || MagicCheck()))
         {
          TicketB[totb] = OrderTicket();
          totb++;
         }
        
        if (OrderType()        == OP_SELL   &&
           (OrderMagicNumber() == magicsell || MagicCheck()))
         {
          TicketS[tots] = OrderTicket();
          tots++;
         }
       }
     }
    else
     {
      Print("Сбой, при переборе ордеров, производится новый расчет");
      
      return; //(0);
     }
   }
  
  //------------------------- Сортировка массивов тикетов -------------------------------
  double pr3 = 0;
  
  //--------------------------------- Для серии BUY -------------------------------------
  for (i = 0; i < totb - 1; i++)
   {
    if (OrderSelect(TicketB[i], SELECT_BY_TICKET))
     {
      pr1 = OrderOpenPrice();
      pr3 = pr1;
      r   = i;
     }
    
    for (j = i + 1; j < totb; j++)
     {
      if (OrderSelect(TicketB[j], SELECT_BY_TICKET))
       {
        pr2 = OrderOpenPrice();
        
        if (pr2 < pr3)
         {
          pr3 = pr2;
          r   = j;
         }
       }
     }
    
    if (r != i)
     {
      j          = TicketB[i];
      TicketB[i] = TicketB[r];
      TicketB[r] = j;
     }
   }
  
  //--------------------------------- Для серии SELL ------------------------------------
  for (i = 0; i < tots - 1; i++)
   {
    if (OrderSelect(TicketS[i], SELECT_BY_TICKET))
     {
      pr1 = OrderOpenPrice();
      pr3 = pr1;
      r   = i;
     }
    
    for (j = i + 1; j < tots; j++)
     {
      if (OrderSelect(TicketS[j], SELECT_BY_TICKET))
       {
        pr2 = OrderOpenPrice();
        
        if (pr2 > pr3)
         {
          pr3 = pr2;
          r   = j;
         }
       }
     }
    
    if (r != i)
     {
      j          = TicketS[i];
      TicketS[i] = TicketS[r];
      TicketS[r] = j;
     }
   }
  
  //----------------- Подсчет профита, объемов и т.д. открытых ордеров ------------------
    
  smbuy  = 0;
  smsell = 0;
  
  for (i = totb - 1; i >= 0; i--)
   if (OrderSelect(TicketB[i], SELECT_BY_TICKET))
    {
     smbuy       += OrderLots();
     profitbuy   += OrderProfit() + OrderCommission() + OrderSwap();
     openpricebuy = OrderOpenPrice();
     lastlotbuy   = OrderLots();
     TPB          = OrderTakeProfit();
    }
  
  for (i = tots - 1; i >= 0; i--)
   if (OrderSelect(TicketS[i], SELECT_BY_TICKET))
    {
     smsell       += OrderLots();
     profitsell   += OrderProfit() + OrderCommission() + OrderSwap();
     openpricesell = OrderOpenPrice();
     lastlotsell   = OrderLots();
     TPS           = OrderTakeProfit();
    }
  
  //---------- Расчет ТП в зависимости от кол-ва ордеров и включенных режимов -----------
  int TPbuy, TPsell;
  
  if (totb == 1)
   TPbuy = TP1;
  else
   TPbuy = TP;
  
  if (tots == 1)
   TPsell = TP1;
  else
   TPsell = TP;
  
  if (DynamicTP)
   {
    TPbuy  += (totb - 1) * TPstep;
    TPsell += (tots - 1) * TPstep;
   }
  
  if (ZTP)
   {
    if (totb >= ZTP_order)
     TPbuy = 0;
    
    if (tots >= ZTP_order)
     TPsell = 0;
   }
  
  //==================================================== Режим работы LOT =============================================
  // --- LOT (Last Orders Take Profit)
  
  double mtpb    = 0, mtps    = 0,
         LO_mtpb = 0, LO_mtps = 0;
  
  int LOtpb, LOtps;
  
  color cLO_mtps = 0, cLO_mtpb = 0;
  
  //-------------------------
  if (LOT)
   {
    //======================================== LOT - Модуль обработки 2-х последних ордеров ===========================
    datetime TimeB = Time[0],
             TimeS = Time[0];
    
    //---
    if (totb > 0)
     if (OrderSelect(TicketB[totb - 1], SELECT_BY_TICKET))
      TimeB = OrderOpenTime();
    
    if (tots > 0)
     if (OrderSelect(TicketS[tots - 1], SELECT_BY_TICKET))
      TimeS = OrderOpenTime();
    
    //---
    if (totb >= nOrder)
     {
      if (OrderSelect(TicketB[0], SELECT_BY_TICKET))
       {
        LastOrdersBuyLots   = OrderLots();
        LastOrdersBuyProfit = OrderProfit() + OrderCommission() + OrderSwap();
       }
      
      if (OrderSelect(TicketB[1], SELECT_BY_TICKET))
       {
        LastOrdersBuyLots   += OrderLots();
        LastOrdersBuyProfit += OrderProfit() + OrderCommission() + OrderSwap();
       }
     }
    
    if (tots >= nOrder)
     {
      if (OrderSelect(TicketS[0], SELECT_BY_TICKET))
       {
        LastOrdersSellLots   = OrderLots();
        LastOrdersSellProfit = OrderProfit() + OrderCommission() + OrderSwap();
       }
      
      if (OrderSelect(TicketS[1], SELECT_BY_TICKET))
       {
        LastOrdersSellLots   += OrderLots();
        LastOrdersSellProfit += OrderProfit() + OrderCommission() + OrderSwap();
       }
     }
    
    //---
    int k = OrdersHistoryTotal() - 1;
    
    BalanceBuy  = AccountBalance();
    BalanceSell = AccountBalance();
    
    while (true)
     {
      if (!OrderSelect(k, SELECT_BY_POS, MODE_HISTORY))
       break;
      
      if ((OrderOpenTime() < TimeB || totb == 0) &&
          (OrderOpenTime() < TimeS || tots == 0))
       break;
      
      if (OrderSymbol() == Symbol())
       {
        if (OrderMagicNumber() == magicbuy &&
            OrderType()        == OP_BUY   &&
            OrderOpenTime()    >  TimeB)
         ProfitBuyN += OrderProfit() + OrderSwap() + OrderCommission();
        
        if (OrderMagicNumber() == magicsell &&
            OrderType()        == OP_SELL   &&
            OrderOpenTime()    >  TimeS)
         ProfitSellN += OrderProfit() + OrderSwap() + OrderCommission();
       }
      
      k--;
     }
    
    BalanceBuy  -= ProfitBuyN;
    BalanceSell -= ProfitSellN;
    
    ProfitBuy  = NormalizeDouble(ProfitBuyN  / BalanceBuy  * 100, 1);
    ProfitSell = NormalizeDouble(ProfitSellN / BalanceSell * 100, 1);
    
    //=================================================== Трал LOT ======================================================
    if (totb >= nOrder)
     {
      if (cLO_mtpb == LOTColor)
       {
        if (Bid <= LO_mtpb && MathAbs((Bid - mtpb) / Point) > spread)
         {
          CloseLastOrdersBuy();
          
          return; //(0);
         }
        
        if (LO_mtpb < (Bid - LO_tral * Point))
         {
          if (NotFast)
           DrawLine("BuyLOT", Bid - LO_tral * Point, LOTColor, 3);
          else
           vLO_mtpb = Bid - LO_tral * Point;
         }
       }
      
      if (cLO_mtpb != LOTColor && Bid >= LO_mtpb + LO_Tral_Start * Point)
       {
        if (NotFast)
         DrawLine("BuyLOT", Bid - LO_Tral_Start * Point, LOTColor, 3);
        else
         vcLO_mtpb = LOTColor;
       }
     }
    
    //-----------------------------------------------------------------------------------
    if (tots >= nOrder)
     {
      if (cLO_mtps == LOTColor)
       {
        if (Ask >= LO_mtps && MathAbs((Ask - mtps) / Point) > spread)
         {
          CloseLastOrdersSell();
          
          return; //(0);
         }
        
        if (LO_mtps > (Ask + LO_tral * Point))
         {
          if (NotFast)
           DrawLine("SellLOT", Ask + LO_tral * Point, LOTColor, 3);
          else
           vLO_mtps = Ask + LO_tral * Point;
         }
       }
      
      if (cLO_mtps != LOTColor && Ask <= LO_mtps - LO_Tral_Start * Point)
       {
        if (NotFast)
         DrawLine("SellLOT", Ask + LO_Tral_Start * Point, LOTColor, 3);
        else
         vcLO_mtps = LOTColor;
       }
     }
    
    //----------------------- Определяем цену и цвет линий LOT --------------------------
    //--------------------------------- Для серии BUY -----------------------------------
    if (hb != totb || (NotFast && (ObjectFind("BuyLOT") < 0 && totb >= nOrder)))
     {
      if (NotFast)
       ObjectDelete("BuyLOT");
      
      hb = totb;
      
      if (totb > 0)
       if (totb >= nOrder)
        {
         LOtpb = (int)NormalizeDouble(Bid + ((- LastOrdersBuyProfit) /
                                               (LastOrdersBuyLots * TV) + (LO_TP + TPstep * (totb - 1))) * Point, Digits);
         
         if (NotFast)
          DrawLine("BuyLOT", LOtpb, BuyColor, 3);
         else
          {
           vLO_mtpb  = LOtpb;
           vcLO_mtpb = BuyColor;
          }
        }
     }
    
    //--------------------------------- Для серии SELL ----------------------------------
    if (hs != tots || (NotFast && (ObjectFind("SellLOT") < 0 && tots >= nOrder)))
     {
      if (NotFast)
       ObjectDelete("SellLOT");
      
      hs = tots;
      
      if (tots > 0)
       if (tots >= nOrder)
        {
         LOtps = (int)NormalizeDouble(Ask - ((- LastOrdersSellProfit) /
                                               (LastOrdersSellLots * TV) + (LO_TP + TPstep * (tots - 1))) * Point, Digits);
         
         if (NotFast)
          DrawLine("SellLOT", LOtps, SellColor, 3);
         else
          {
           vLO_mtps  = LOtps;
           vcLO_mtps = SellColor;
          }
        }
     }
    
    //--- BuyLOT
    if (NotFast && ObjectFind("BuyLOT") == 0)
     {
      LO_mtpb  =        ObjectGet("BuyLOT",  OBJPROP_PRICE1);
      cLO_mtpb = (color)ObjectGet("BuyLOT",  OBJPROP_COLOR);
     }
    else
     {
      LO_mtpb  = vLO_mtpb;
      cLO_mtpb = vcLO_mtpb;
     }
    
    //--- SellLOT
    if (NotFast && ObjectFind("SellLOT") == 0)
     {
      LO_mtps  =        ObjectGet("SellLOT", OBJPROP_PRICE1);
      cLO_mtps = (color)ObjectGet("SellLOT", OBJPROP_COLOR);
     }
    else
     {
      LO_mtps  = vLO_mtps;
      cLO_mtps = vcLO_mtps;
     }
   }
  
  //========================================= модуль Расчета ТейкПрофита для обоих серий ==============================
  double tpb,  tps,
         ztpb, ztps;
  
  //--------------------------------- Для серии BUY -------------------------------------
  if (hb != totb || (NotFast && (ObjectFind("BuyTP")        < 0 ||
                                 ObjectFind("BuyZeroLevel") < 0)))
   {
    if (NotFast)
     {
      ObjectDelete("BuyTP");
      ObjectDelete("BuyZeroLevel");
      ObjectDelete("BuyTP_Back");
      ObjectDelete("BuyTP_Text");
     }
    
    hb = totb;
    
    if (totb > 0)
     {
      ztpb = NormalizeDouble(Bid, Digits) - NormalizeDouble((profitbuy / (smbuy * TV)) * Point, Digits);
      
      if (CurrencyProfit)
       {
        double PrPB = BalanceBuy * Profit / 100;
        
        tpb = ztpb + NormalizeDouble(PrPB / (smbuy * TV) * Point, Digits);
       }
      else
       tpb = ztpb + TPbuy * Point;
      
      if (NotFast)
       {
        DrawLine("BuyTP", tpb, BuyColor, 2);
        
        DrawLine("BuyZeroLevel", ztpb, BuyColor, 0);
       }
      else
       {
        vctpb = BuyColor;
        vmtpb = tpb;
       }
     }
   }
  
  //--------------------------------- Для серии SELL ------------------------------------
  if (hs != tots || (NotFast && (ObjectFind("SellTP")        < 0 ||
                                 ObjectFind("SellZeroLevel") < 0)))
   {
    if (NotFast)
     {
      ObjectDelete("SellTP");
      ObjectDelete("SellZeroLevel");
      ObjectDelete("SellTP_Back");
      ObjectDelete("SellTP_Text");
     }
    
    hs = tots;
    
    if (tots > 0)
     {
      ztps = NormalizeDouble(Ask, Digits) + NormalizeDouble((profitsell / (smsell * TV)) * Point, Digits);
      
      if (CurrencyProfit)
       {
        double PrPS = BalanceSell * Profit / 100;
        
        tps = ztps - NormalizeDouble(PrPS / (smsell * TV) * Point, Digits);
       }
      else
       tps = ztps - TPsell * Point;
      
      if (NotFast)
       {
        DrawLine("SellTP", tps, SellColor, 2);
        
        DrawLine("SellZeroLevel", ztps, SellColor, 0);
       }
      else
       {
        vctps = SellColor;
        vmtps = tps;
       }
     }
   }
  
  //----------------------- Определяем цену и цвет линий ТП -----------------------------
  color ctpb = 0,
        ctps = 0;
  
  //--- BuyTP
  if (NotFast && ObjectFind("BuyTP") == 0)
   {
    mtpb = ObjectGet("BuyTP", OBJPROP_PRICE1);
    ctpb = (color)ObjectGet("BuyTP", OBJPROP_COLOR);
    ztpb = ObjectGet("BuyZeroLevel", OBJPROP_PRICE1);
    
    double ptpb  = (mtpb - Bid)  / Point * smbuy * TV + profitbuy;
    double pptpb = (mtpb - ztpb) / Point;
    
    TextT("BuyTP_Back", "gggggggggg", mtpb, "Webdings", ctpb);
    TextT("BuyTP_Text", DoubleToStr(ptpb, 2) + " / " + DoubleToStr(pptpb, 0), mtpb, "Arial Black", Black);
   }
  else
   {
    mtpb = vmtpb;
    ctpb = vctpb;
   }
  
  //--- SellTP
  if (NotFast && ObjectFind("SellTP") == 0)
   {
    mtps = ObjectGet("SellTP",OBJPROP_PRICE1);
    ctps = (color)ObjectGet("SellTP",OBJPROP_COLOR);
    ztps = ObjectGet("SellZeroLevel",OBJPROP_PRICE1);
    
    double ptps  = (Ask  - mtps) / Point * smsell * TV + profitsell;
    double pptps = (ztps - mtps) / Point;
    
    TextT("SellTP_Back", "gggggggggg", mtps, "Webdings", ctps);
    TextT("SellTP_Text", DoubleToStr(ptps, 2) + " / " + DoubleToStr(pptps, 0), mtps, "Arial Black", Black);
   }
  else
   {
    mtps = vmtps;
    ctps = vctps;
   }
  
  //====================================================== Трал VTP ===================================================
  if (UseVTP)
   {
    if (totb > 0)
     {
      if (ctpb == TralColor)
       {
        if (Bid <= mtpb)
         {
          closeBUYorders();
          
          return; //(0);
         }
        
        if (mtpb < (Bid - tral * Point))
         {
          if (NotFast)
           DrawLine("BuyTP", Bid - tral * Point, TralColor, 2);
          else
           vmtpb = Bid - tral * Point;
         }
       }
      
      if (ctpb != TralColor && Bid >= mtpb + Tral_Start * Point)
       {
        if (NotFast)
         DrawLine("BuyTP", Bid - Tral_Start * Point, TralColor, 2);
        else
         vctpb = TralColor;
       }
     }
    
    //-----------------------------------------------------------------------------------
    if (tots > 0)
     {
      if (ctps == TralColor)
       {
        if (Ask >= mtps)
         {
          closeSELLorders();
          
          return; //(0);
         }
        
        if (mtps > (Ask + tral * Point))
         {
          if (NotFast)
           DrawLine("SellTP", Ask + tral * Point, TralColor, 2);
          else
           vmtps = Ask + tral * Point;
         }
       }
      
      if (ctps != TralColor && Ask <= mtps - Tral_Start * Point)
       {
        if (NotFast)
         DrawLine("SellTP", Ask + Tral_Start * Point, TralColor, 2);
        else
         vctps = TralColor;
       }
     }
   }
  
  //========================================== Модификация ордеров при выключенном VTP ================================
  if (!UseVTP)
   {
    bool q = false;
    
    //-----------------------------------------------------------------------------------
    if (totb > 0 && MathAbs((TPB - NormalizeDouble(mtpb, Digits)) / Point) > CU &&
                    MathAbs((Bid - NormalizeDouble(mtpb, Digits)) / Point) > spread)
     {
      for (i = 0; i < totb; i++)
       {
        if(OrderSelect(TicketB[i], SELECT_BY_TICKET))
        
        while (!q)
         {
          q = OrderModify(OrderTicket(), OrderOpenPrice(), 0, NormalizeDouble(mtpb, Digits), 0);
          
          Sleep(1000);
         }
        
        q = false;
       }
     }
    
    //-----------------------------------------------------------------------------------
    if (tots > 0 && MathAbs((TPS - NormalizeDouble(mtps, Digits)) / Point) > CU &&
                    MathAbs((Ask - NormalizeDouble(mtps, Digits)) / Point) > spread)
     {
      for (i = 0; i < tots; i++)
       {
        if(OrderSelect(TicketS[i], SELECT_BY_TICKET))
        
        while (!q)
         {
          q = OrderModify(OrderTicket(), OrderOpenPrice(), 0, NormalizeDouble(mtps, Digits), 0);
          
          Sleep(1000);
         }
        
        q = false;
       }
     }
   }
  
  //================================================= Подчет уровня просадки===========================================
  double dd = 0;
  
  if (profitbuy + profitsell < 0)
   dd = MathAbs(profitbuy + profitsell) / (AccountEquity() - (profitbuy + profitsell)) * 100;
  
  if (DrawdownStop && dd >= SL_Level && (profitbuy + profitsell) < 0)
   {
    if (totb > 0)
     closeBUYorders();
    
    if (tots > 0)
     closeSELLorders();
   }
  
  if (LOT && (ProfitBuyN + profitbuy) >= BalanceBuy * ProfitPercent / 100)
   closeBUYorders();
  
  if (LOT && (ProfitSellN + profitsell) >= BalanceSell * ProfitPercent / 100)
   closeSELLorders();
  
  //================================================== Визуализация информации ========================================
  if (NotFast)
   {
    //------------------------------------------------------- Удаление устаревших объектов ----------------------------------------------------------
    for (int ii = ObjectsTotal() - 1; ii >= 0; ii--)
     {
      string ObName = ObjectName(ii);
      
      if (ObjectGet(ObName, OBJPROP_TIME1) > 0 &&
          ObjectGet(ObName, OBJPROP_TIME1) < (Time[0] - DaysBuffer * 86400))
       {
        if (ObName != "SellTP"        &&
            ObName != "SellLOT"       &&
            ObName != "SellZeroLevel" &&
            ObName != "SellTP_Back"   &&
            ObName != "SellTP_Text"   &&
            ObName != "BuyTP"         &&
            ObName != "BuyZeroLevel"  &&
            ObName != "BuyTP_Back"    &&
            ObName != "BuyTP_Text"    &&
            ObName != "BuyLOT")
         ObjectDelete(ObName);
       }
     }
    
    //--------------------------------------------------- Отображение Баланс/Средства/Просадка ------------------------------------------------------
    if (Info)
     {
      // изменение цвета при уменьшении "СРЕДСТВА" относительно "БАЛАНС"
      double Balans   = NormalizeDouble(AccountBalance(), 0);
      double Sredstva = NormalizeDouble(AccountEquity(),  0);
      
      if (Sredstva >= Balans / 6 * 5)
       col = DodgerBlue;
      
      if (Sredstva >= Balans / 6 * 4 &&
          Sredstva <  Balans / 6 * 5)
       col = DeepSkyBlue;
      
      if (Sredstva >= Balans / 6 * 3 &&
          Sredstva <  Balans / 6 * 4)
       col = Gold;
      
      if (Sredstva >= Balans / 6 * 2 &&
          Sredstva <  Balans / 6 * 3)
       col = OrangeRed;
      
      if (Sredstva >= Balans / 6 &&
          Sredstva <  Balans /6 * 2)
       col = Crimson;
      
      if (Sredstva < Balans / 5)
       col = Red;
      
      //-------------------------
      ObjectCreate ("Lable1", OBJ_LABEL, 0, 0, 1.0);
      ObjectSet    ("Lable1", OBJPROP_CORNER, 3);
      ObjectSet    ("Lable1", OBJPROP_XDISTANCE, 10);
      ObjectSet    ("Lable1", OBJPROP_YDISTANCE, 51);
      txt1 = (DoubleToStr(AccountBalance(), 2));
      ObjectSetText("Lable1", "БАЛАНС     " + txt1 + "", 12, "Times New Roman", DodgerBlue);
      
      //-------------------------
      ObjectCreate ("Lable2", OBJ_LABEL, 0, 0, 1.0);
      ObjectSet    ("Lable2", OBJPROP_CORNER, 3);
      ObjectSet    ("Lable2", OBJPROP_XDISTANCE, 10);
      ObjectSet    ("Lable2", OBJPROP_YDISTANCE, 31);
      txt2 = (DoubleToStr(AccountEquity(), 2));
      ObjectSetText("Lable2", "СРЕДСТВА     " + txt2 + "", 12, "Times New Roman", col);
      
      //-------------------------
      ObjectCreate ("Lable3", OBJ_LABEL, 0, 0, 1.0);
      ObjectSet    ("Lable3", OBJPROP_CORNER, 3);
      ObjectSet    ("Lable3", OBJPROP_XDISTANCE, 10);
      ObjectSet    ("Lable3", OBJPROP_YDISTANCE, 11);
      txt4 = DoubleToStr(dd, 3) + "%";
      ObjectSetText("Lable3", "ПРОСАДКА     " + txt4 + "", 12, "Times New Roman", Green);
      
      //--------------------------------------------------------- Отображение инфопанелей -----------------------------------------------------------
      string spips; 
      
      double    pips = 0;
      
      double stopout_balance = AccountMargin() * AccountStopoutLevel() / 100;
      
      if (MathAbs(smbuy - smsell) > 0)
       pips = NormalizeDouble((AccountEquity() - stopout_balance) / MathAbs(smbuy - smsell) / TV, 0);
      
      if (smbuy > smsell)
       spips = StringConcatenate("До слива ",pips," пунктов вниз");
      
      if (smbuy < smsell)
       spips = StringConcatenate("До слива ",pips," пунктов вверх");
      
      if (smbuy == smsell)
       {
        if (smbuy == 0)
         spips = "Нет ордеров";
        else
         spips = "Лок";
       }
      
      if (UseVTP)
       txtVTP = "Режим VTP вкл. ";
      else
       txtVTP = "Режим VTP выкл.";
      
      if (LOT)
       txtLOT = "Режим LOT вкл. ";
      else
       txtLOT = "Режим LOT выкл.";
      
      int x1, y1, x2, y2, x3, y3;
      
      if (ObjectFind("y_MainInfoBack1") == -1)
       Text("y_MainInfoBack1", "gggg", 58, "Webdings", 0, 0, MainInfoBack);
      
      if (ObjectFind("y_MainInfoBack2") == -1)
       Text("y_MainInfoBack2", "gggg", 58, "Webdings", 320, 0, BuyInfoBack);
      
      if (ObjectFind("y_MainInfoBack3") == -1)
       Text("y_MainInfoBack3", "gggg", 58, "Webdings", 640, 0, SellInfoBack);
      
      //-------------------------
      x1 = (int)ObjectGet("y_MainInfoBack1", OBJPROP_XDISTANCE);
      y1 = (int)ObjectGet("y_MainInfoBack1", OBJPROP_YDISTANCE);
      x2 = (int)ObjectGet("y_MainInfoBack2", OBJPROP_XDISTANCE);
      y2 = (int)ObjectGet("y_MainInfoBack2", OBJPROP_YDISTANCE);
      x3 = (int)ObjectGet("y_MainInfoBack3", OBJPROP_XDISTANCE);
      y3 = (int)ObjectGet("y_MainInfoBack3", OBJPROP_YDISTANCE);
      
      //-------------------------
      Text("z_MainInfo_1", txtVTP, 9, "Arial Black", x1 + 20,  y1 + 6, MainInfo);
      Text("z_MainInfo_2", txtLOT, 9, "Arial Black", x1 + 165, y1 + 6, MainInfo);
      Text("z_MainInfo_3", "мин.лот:  "  + DoubleToStr(minLot, 2),            9, "Arial Black", x1 + 20,  y1 + 21, MainInfo);
      Text("z_MainInfo_4", "макс.лот:  " + DoubleToStr(maxLot, 0),            9, "Arial Black", x1 + 165, y1 + 21, MainInfo);
      Text("z_MainInfo_5", "спред:  "    + DoubleToStr(spread, 0) + "п",      9, "Arial Black", x1 + 20,  y1 + 36, MainInfo);
      Text("z_MainInfo_6", "плечо:  1:"  + DoubleToStr(AccountLeverage(), 0), 9, "Arial Black", x1 + 165, y1 + 36, MainInfo);
      Text("z_MainInfo_7", spips, 9, "Arial Black", x1 + 20, y1 + 51, MainInfo);
      
      //-------------------------
      Text("z_BuyInfo_1", "BUY", 9, "Arial Black", x2 + 130, y2 + 6, BuyInfo);
      Text("z_BuyInfo_2", "Ордеров:  " + DoubleToStr(totb, 0),         9, "Arial Black", x2 +20,  y2 +21, BuyInfo);
      Text("z_BuyInfo_3", "Объем:  "   + DoubleToStr(smbuy, 2),        9, "Arial Black", x2 +165, y2 +21, BuyInfo);
      Text("z_BuyInfo_4", "Ур.TP:  "   + DoubleToStr(mtpb, Digits),    9, "Arial Black", x2 +20,  y2 +36, BuyInfo);
      Text("z_BuyInfo_5", "Ур.LOTP:  " + DoubleToStr(LO_mtpb, Digits), 9, "Arial Black", x2 +165, y2 +36, BuyInfo);
      Text("z_BuyInfo_6", "Профит:  "  + DoubleToStr(profitbuy, 2),    9, "Arial Black", x2 +20,  y2 +51, BuyInfo);
      
      if (LOT)
       Text("z_BuyInfo_7", "Нак.профит:  " + DoubleToStr(ProfitBuy, 2) + "%", 9, "Arial Black", x2 + 165, y2 + 51, BuyInfo);
      
      //-------------------------
      Text("z_SellInfo_1", "SELL", 9, "Arial Black", x3 + 125, y3 + 6, SellInfo);
      Text("z_SellInfo_2", "Ордеров:  " + DoubleToStr(tots, 0),         9, "Arial Black", x3 + 20,  y3 + 21, SellInfo);
      Text("z_SellInfo_3", "Объем:  "   + DoubleToStr(smsell, 2),       9, "Arial Black", x3 + 165, y3 + 21, SellInfo);
      Text("z_SellInfo_4", "Ур.TP:  "   + DoubleToStr(mtps, Digits),    9, "Arial Black", x3 + 20,  y3 + 36, SellInfo);
      Text("z_SellInfo_5", "Ур.LOTP:  " + DoubleToStr(LO_mtps, Digits), 9, "Arial Black", x3 + 165, y3 + 36, SellInfo);
      Text("z_SellInfo_6", "Профит:  "  + DoubleToStr(profitsell, 2),   9, "Arial Black", x3 + 20,  y3 + 51, SellInfo);
      
      if (LOT)
       Text("z_SellInfo_7", "Нак.профит:  " + DoubleToStr(ProfitSell, 2) + "%", 9, "Arial Black", x3 + 165, y3 + 51, SellInfo);
     }
   }
  
  //================================================ Усреднение позиций BUY ===========================================
  if (totb > 0)
   {
    if ((UseNewBar && NewBar_B != iTime(Symbol(), UNB_TF, 0)) || !UseNewBar)
     {
      if (Ask <= openpricebuy - MathFloor(step * MathPow(Step_coef, totb - 1)) * Point && totb < MaxTrades)
       {
        double lotsbuy2 = lastlotbuy * mult;
        
        NewBar_B = iTime(Symbol(), UNB_TF, 0);
        
        if (AccountFreeMarginCheck(Symbol(), OP_BUY, lotsbuy2) > 0)
         ОткрытьОрдер(OP_BUY, lotsbuy2,StringConcatenate("",totb + 1, "-й ордер Buy, ", magicbuy), magicbuy);
       }
     }
   }
  
  //=================================================== Усреднение позиций SELL =======================================
  if (tots > 0)
   {
    if ((UseNewBar && NewBar_S != iTime(Symbol(), UNB_TF, 0)) || !UseNewBar)
     {
      if (Bid >= openpricesell + MathFloor(step * MathPow(Step_coef, tots - 1)) * Point && tots < MaxTrades)
       {
        double lotssell2 = lastlotsell * mult;
        
        NewBar_S = iTime(Symbol(), UNB_TF, 0);
        
        if (AccountFreeMarginCheck(Symbol(), OP_SELL,lotssell2) > 0)
         ОткрытьОрдер(OP_SELL, lotssell2, StringConcatenate("",tots + 1, "-й ордер Sell, " ,magicsell), magicsell);
       }
     }
   }
  
  //============================================== Открытие 1-го ордера по индикатору =================================
  lotsbuy = 0; lotssell = 0;
  
  //---------------------------------------- Открытие ордера по BUY ---------------------
  if (time() && totb == 0)
   if ((UseNewBar && NewBar_B != iTime(Symbol(), StochTime, 0)) || !UseNewBar)
    {
     if (!ManualTrade && Stochastic("buy"))
      {
       if (UseMM)
        {
         lotsbuy = MM(mult, UseMoney, MaxTrades, step);
         
         if (lotsbuy < minLot)
          {
           TradeStop();
           
           return; //(0);
          }
        }
       else
        lotsbuy = min_lot;
       
       if (AccountFreeMarginCheck(Symbol(), OP_BUY, lotsbuy) > 0)
        ОткрытьОрдер(OP_BUY, lotsbuy,StringConcatenate("1-й ордер Buy, ", magicbuy), magicbuy);
       
       NewBar_B = iTime(Symbol(), UNB_TF, 0);
      }
    }
   
   //--------------------------------------- Открытие ордера по Sell --------------------
   if (time() && tots == 0)
    if ((UseNewBar && NewBar_S != iTime(Symbol(), StochTime, 0)) || !UseNewBar)
     {
      if (!ManualTrade && Stochastic("sell"))
       {
        if (UseMM)
         {
          lotssell = MM(mult, UseMoney, MaxTrades, step);
          
          if (lotssell < minLot)
           {
            TradeStop();
            
            return; //(0);
           }
         }
        else
         lotssell = min_lot;
        
        if (AccountFreeMarginCheck(Symbol(), OP_SELL, lotssell) > 0)
         ОткрытьОрдер(OP_SELL, lotssell,StringConcatenate("1-й ордер Sell, ", magicsell), magicsell);
        
        NewBar_S = iTime(Symbol(), UNB_TF, 0);
       }
     }
   
  //===================================================================================================================
  return; // (0);
 }
//===================================================================================================================================================
//===================================================================== Ф У Н К Ц И И ===============================================================
//===================================================================================================================================================
bool time()
 {
  if (StartHour < EndHour)
   {
    if (Hour() >= StartHour &&
        Hour() <  EndHour)
     return(true);
    else
     return(false);
   }
  
  if (StartHour > EndHour)
   {
    if (Hour() >= EndHour &&
        Hour() <  StartHour)
     return(false);
    else
     return(true);
   }
  
  //-------------------------
  return(false);
 }
//===================================================================================================================================================
bool Stochastic(string SMode)
 {
  double sM0 = iStochastic(Symbol(), StochTime, per_K, per_D, slow, S_Mode, S_Price, MODE_MAIN, 0);
  double sM1 = iStochastic(Symbol(), StochTime, per_K, per_D, slow, S_Mode, S_Price, MODE_MAIN, 1);
  
  double sS0 = iStochastic(Symbol(), StochTime, per_K, per_D, slow, S_Mode, S_Price, MODE_SIGNAL, 0);
  double sS1 = iStochastic(Symbol(), StochTime, per_K, per_D, slow, S_Mode, S_Price, MODE_SIGNAL, 1);
  
  if (SMode == "buy" && sS0 < zoneBUY &&
                        sM0 < zoneBUY && sM1 <  sS1 &&
                                         sM0 >= sS0)
   return(true);
  
  if (SMode == "sell" && sS0 > zoneSELL &&
                         sM0 > zoneSELL && sM1 >  sS1 &&
                                           sM0 <= sS0)
   return(true);
  
  return(false);
 }
//===================================================================================================================================================
void closeBUYorders()
 {
  int ii, tt, jj;
  
  bool q;
  
  if (CloseBy && !IsTesting())
   {
    while (ОткрытьОрдер(OP_SELL, smbuy, "", magiclock) <= 0)
     Sleep(1000);
    
    for (ii = 0; ii < totb; ii++)
     {
      tt = 0;
      
      for (jj = OrdersTotal() - 1; jj >= 0; jj--)
       {
        if (OrderSelect(jj, SELECT_BY_POS, MODE_TRADES))
         {
          if (OrderSymbol()      == Symbol() &&
              OrderType()        == OP_SELL  &&
              OrderMagicNumber() == magiclock)
           {
            tt = OrderTicket();
            
            break;
           }
         }
       }
      
      q = false;
      
      while (!q)
       {
        RefreshRates();
        
        q = OrderCloseBy(TicketB[ii], tt, BuyColor);
        
        Sleep(1000);
       }
     }
   }
  else
   {
    for (ii = 0; ii < totb; ii++)
     {
      if (OrderSelect(TicketB[ii], SELECT_BY_TICKET))
       {
        q = false;
        
        while (!q)
         {
          RefreshRates();
          
          q = OrderClose(TicketB[ii], OrderLots(), NormalizeDouble(Bid, Digits), slippage, BuyColor);
          
          Sleep(1000);
         }
       }
     }
   }
 }
//===================================================================================================================================================
void closeSELLorders()
 {
  int ii, tt, jj;
  
  bool q;
  
  if (CloseBy && !IsTesting())
   {
    while (ОткрытьОрдер(OP_BUY, smsell, "", magiclock) <= 0)
     Sleep(1000);
    
    for (ii = 0; ii < tots; ii++)
     {
      tt = 0;
      
      for (jj = OrdersTotal() - 1; jj >= 0; jj--)
       {
        if (OrderSelect(jj, SELECT_BY_POS, MODE_TRADES))
         {
          if (OrderSymbol()      == Symbol() &&
              OrderType()        == OP_BUY   &&
              OrderMagicNumber() == magiclock)
           {
            tt = OrderTicket();
            
            break;
           }
         }
       }
      
      q = false;
      
      while (!q)
       {
        RefreshRates();
        
        q = OrderCloseBy(TicketS[ii], tt, SellColor);
        
        Sleep(1000);
       }
     }
   }
  else
   {
    for (ii = 0; ii < tots; ii++)
     {
      if (OrderSelect(TicketS[ii], SELECT_BY_TICKET))
       {
        q = false;
        
        while (!q)
         {
          RefreshRates();
          
          q = OrderClose(TicketS[ii], OrderLots(), NormalizeDouble(Ask, Digits), slippage, SellColor);
          
          Sleep(1000);
         }
       }
     }
   }
 }
//===================================================================================================================================================
void CloseLastOrdersBuy()
 {
  int ii;
  
  bool q;
  
  for (ii = 0; ii < 2; ii++)
   {
    if (OrderSelect(TicketB[ii], SELECT_BY_TICKET))
     {
      q = false;
      
      while (!q)
       {
        RefreshRates();
        
        q = OrderClose(TicketB[ii], OrderLots(), NormalizeDouble(Bid, Digits), slippage, BuyColor);
        
        Sleep(1000);
       }
     }
   }
 }
//===================================================================================================================================================
void CloseLastOrdersSell()
 {
  int ii;
  
  bool q;
  
  for (ii = 0; ii < 2; ii++)
   {
    if (OrderSelect(TicketS[ii], SELECT_BY_TICKET))
     {
      q = false;
      
      while(!q)
       {
        RefreshRates();
        
        q = OrderClose(TicketS[ii], OrderLots(), NormalizeDouble(Ask, Digits), slippage, SellColor);
        
        Sleep(1000);
       }
     }
   }
 }
//====================================================================== блок ММ ====================================================================
double MM(double mult1, int UM, int MaxTrades1, int step1)
 {
  double trade_vol = 1;
  double sum_vol   = 1;
  
  double MaxDrawdown=0;
  
  maxLot = MarketInfo(Symbol(), MODE_MAXLOT);
  
  double margin = MarketInfo(Symbol(), MODE_MARGINREQUIRED);
  double TV1    = MarketInfo(Symbol(), MODE_TICKVALUE);
  
  int cnt2, cnt3;
  
  double marginsum, points;
  
  for (cnt2 = MaxTrades1; cnt2 >= 1; cnt2--)
   {
    points = 0;
    
    for (cnt3 = MaxTrades1 - cnt2; cnt3 < MaxTrades1; cnt3++)
     {
      points += NormalizeDouble(step * MathPow(Step_coef, cnt3), 0);
     }
    
    MaxDrawdown += trade_vol * points * TV1;                              // расчет максимальной просадки при объеме 1-го ордера в 1.00 лот
    sum_vol     += trade_vol;
    trade_vol   *= mult1;
   }
  
  marginsum = margin * sum_vol;
  
  double depo;
  
  if (UseEquity)
   depo = AccountEquity();
  else
   depo = AccountBalance();
  
  double lot = NormalizeDouble(((depo + AccountCredit()) * UM / 100) / (MaxDrawdown + marginsum), dig);  // расчет максимального объема для 1-го ордера серии
  
  if (lot * sum_vol > maxLot)                                                                            // проверка на максимально возможный объем 1-го ордера серии
   lot = NormalizeDouble(maxLot / sum_vol, dig);
  
  return(lot);
 }
//===================================================================================================================================================
void TradeStop()
 {
  if (totb + tots > 0)
   return; //(0);
  
  int cnt2, cnt3;
  
  double trade_vol = 1, points;
  double sum_vol   = 1;
  double MaxDrawdown = 0, marginsum;
  
  minLot = MarketInfo(Symbol(), MODE_MINLOT);
  
  double margin = MarketInfo(Symbol(), MODE_MARGINREQUIRED);
  double TV1    = MarketInfo(Symbol(), MODE_TICKVALUE);
  
  for (cnt2 = MaxTrades; cnt2 >= 1; cnt2--)
   {
    points = 0;
    
    for (cnt3 = MaxTrades - cnt2; cnt3 < MaxTrades; cnt3++)
     {
      points += NormalizeDouble(step * MathPow(Step_coef, cnt3), 0);
     }
    
    MaxDrawdown += trade_vol * points * TV1;
    sum_vol     += trade_vol;
    trade_vol   *= mult;
   }
  
  marginsum = margin * sum_vol;
  
  double deposit = minLot * (MaxDrawdown + marginsum) / UseMoney * 100;
  
  tm = StringConcatenate("Недостаточно средств, необходимо ",deposit, " ед.");
  
  TradeOff = true;
 }
//===================================================================================================================================================
void Text(string name, string text, int size, string font, int xd, int yd, color colT)
 {
  int w = WindowFind("2SS");
  
  if (w == -1)
   w = 0;
  
  if (ObjectFind("y_MainInfoBack1") != w)
   ObjectDelete("y_MainInfoBack1");
  
  if (ObjectFind("y_MainInfoBack2") != w)
   ObjectDelete("y_MainInfoBack2");
  
  if (ObjectFind("y_MainInfoBack3") != w)
   ObjectDelete("y_MainInfoBack3");
  
  if (ObjectFind(name) == 0 && w != 0)
   ObjectDelete(name);
  
  ObjectCreate (name, OBJ_LABEL, w, 0, 0);
  ObjectSetText(name, text, size, font);
  ObjectSet    (name, OBJPROP_XDISTANCE, xd);
  ObjectSet    (name, OBJPROP_YDISTANCE, yd);
  ObjectSet    (name, OBJPROP_COLOR, colT);
  ObjectSet    (name, OBJPROP_BACK, false);
 }
//===================================================================================================================================================
void TextT(string name, string txt, double y, string sh, color C)
 { 
  cntr = (int)MathFloor(WindowFirstVisibleBar() / 2);
    
  bool q=false;
  
  if (ObjectFind(name) != 0)
   ObjectCreate(name, OBJ_TEXT, 0, Time[cntr], y);
  else
   q = ObjectMove(name, 0, Time[cntr], y);
  
  if (!q)
   Print(DoubleToStr(cntr,3), " ", Time[cntr]);
  
  ObjectSetText(name, txt, 10, sh, C);
 }
//===================================================================================================================================================
void DrawLine(string name,double price, color _col, int w)
 {
  cntr = (int)MathFloor(WindowFirstVisibleBar() / 2);
    
  bool q=false;
  
  if (ObjectFind(name) != 0)
   ObjectCreate(name, OBJ_HLINE, 0, Time[cntr], price);
  else
   q = ObjectMove(name, 0, Time[cntr], price);
  
  if (!q)
   Print(DoubleToStr(cntr, 3), " ", Time[cntr]);
  
  ObjectSet(name, OBJPROP_COLOR, _col);
  ObjectSet(name, OBJPROP_WIDTH, w);
 }
//===================================================================================================================================================
int ОткрытьОрдер(int тип, double объем, string комент, int мэджик)
 {
  if (!IsTradeAllowed())
   return(0);
  
  
  double cena = 0;
  
  color cvet = 0;
  
  string ордер;
  
  RefreshRates();
  
  switch (тип)
   {
    case OP_BUY  : cena  = Ask;
                   cvet  = BuyColor;
                   ордер = "Buy";
                   break;
    case OP_SELL : cena  = Bid;
                   cvet  = SellColor;
                   ордер = "Sell";
   }
  
  int t = OrderSend(Symbol(), тип, NormalizeDouble(объем, 2),
                                   NormalizeDouble(cena, Digits), slippage, 0, 0, комент, мэджик, 0, cvet);
  
  Sleep(1000);
  
  return(t);
 }
//===================================================================================================================================================
bool MagicCheck()
 {
  for (int ii = 0; ii < cmagic; ii++)
   {
    if (OrderMagicNumber() == magic[ii])
     return(true);
   }
  
  return(false);
 }
//===================================================================================================================================================
